/**
 * 中文映射封装 (zh-map.js)
 * 支持 ES6 Map 映射操作 + 链式调用（返回新映射，不修改原始 Map）
 * 中文方法命名 + JSDoc 参数提示
 */

class 映射 {
  /**
   * 构造函数 - 创建映射实例
   * @param {Iterable<Array<*>>} [值=[]] 可迭代对象初始化映射（键值对数组）
   */
  constructor(值 = []) {
    this._值 = new Map(值);
  }

  /**
   * 获取原始 Map 的副本
   * @returns {Map} 映射数据的副本
   */
  取值() {
    return new Map(this._值);
  }

  /**
   * 打印映射内容到控制台
   * @returns {映射} 返回this以支持链式调用
   */
  打印() {
    console.log(this._值);
    return this;
  }

  /**
   * 添加键值对，返回新映射（不修改原映射）
   * @param {*} 键 键
   * @param {*} 值 值
   * @returns {映射} 新的映射实例
   */
  添加(键, 值) {
    const 新映射 = new Map(this._值);
    新映射.set(键, 值);
    return new 映射(新映射);
  }

  /**
   * 批量添加键值对，返回新映射（不修改原映射）
   * @param {Array<Array<*>>} 条目数组 键值对数组
   * @returns {映射} 新的映射实例
   */
  批量添加(条目数组) {
    const 新映射 = new Map(this._值);
    for (const [键, 值] of 条目数组) {
      新映射.set(键, 值);
    }
    return new 映射(新映射);
  }

  /**
   * 删除指定键的键值对，返回新映射（不修改原映射）
   * @param {*} 键 要删除的键
   * @returns {映射} 新的映射实例
   */
  删除(键) {
    const 新映射 = new Map(this._值);
    新映射.delete(键);
    return new 映射(新映射);
  }

  /**
   * 批量删除多个键的键值对，返回新映射（不修改原映射）
   * @param {...*} 键列表 要删除的键列表
   * @returns {映射} 新的映射实例
   */
  批量删除(...键列表) {
    const 新映射 = new Map(this._值);
    for (const 键 of 键列表) {
      新映射.delete(键);
    }
    return new 映射(新映射);
  }

  /**
   * 判断映射是否包含指定键
   * @param {*} 键 要检查的键
   * @returns {boolean} 是否包含该键
   */
  包含(键) {
    return this._值.has(键);
  }

  /**
   * 获取指定键对应的值
   * @param {*} 键 键
   * @returns {*} 对应的值，如果键不存在则返回undefined
   */
  取(键) {
    return this._值.get(键);
  }

  /**
   * 返回空映射（不修改原映射）
   * @returns {映射} 空映射实例
   */
  清空() {
    return new 映射();
  }

  /**
   * 获取映射中键值对数量
   * @returns {number} 映射的大小
   */
  大小() {
    return this._值.size;
  }

  /**
   * 将映射转换为条目数组
   * @returns {Array<Array<*>>} 包含所有键值对的数组
   */
  转数组() {
    return [...this._值];
  }

  /**
   * 获取映射中所有的键
   * @returns {Array<*>} 键数组
   */
  取键() {
    return [...this._值.keys()];
  }

  /**
   * 获取映射中所有的值
   * @returns {Array<*>} 值数组
   */
  取值列表() {
    return [...this._值.values()];
  }

  /**
   * 获取映射中所有的条目
   * @returns {Array<Array<*>>} 条目数组
   */
  取条目() {
    return [...this._值.entries()];
  }

  /**
   * 遍历映射中所有键值对
   * @param {Function} 回调 遍历回调函数，接收(值,键,映射)参数
   * @returns {映射} 返回this以支持链式调用
   */
  遍历(回调) {
    this._值.forEach(回调);
    return this;
  }

  /**
   * 合并多个映射，返回新映射
   * @param {...Map|...映射} 映射项 要合并的映射
   * @returns {映射} 合并后的新映射实例
   */
  合并(...映射项) {
    const 新映射 = new Map(this._值);
    for (const m of 映射项) {
      const 源映射 = m instanceof 映射 ? m._值 : m;
      for (const [k, v] of 源映射) {
        新映射.set(k, v);
      }
    }
    return new 映射(新映射);
  }

  /**
   * 对映射中的每个值执行映射操作，返回新映射
   * @param {Function} 回调 映射函数，接收(值,键,映射)参数
   * @returns {映射} 新的映射实例
   */
  映射值(回调) {
    const 新映射 = new Map();
    for (const [k, v] of this._值) {
      新映射.set(k, 回调(v, k, this._值));
    }
    return new 映射(新映射);
  }

  /**
   * 过滤映射中的键值对，返回满足条件的键值对组成的新映射
   * @param {Function} 回调 过滤函数，接收(值,键,映射)参数
   * @returns {映射} 新的映射实例
   */
  过滤(回调) {
    const 新映射 = new Map();
    for (const [k, v] of this._值) {
      if (回调(v, k, this._值)) {
        新映射.set(k, v);
      }
    }
    return new 映射(新映射);
  }

  /**
   * 创建映射的深拷贝
   * @returns {映射} 新的映射实例
   */
  克隆() {
    return new 映射(this._值);
  }

  /** 静态方法 */

  /**
   * 静态方法：判断对象是否为Map实例
   * @static
   * @param {*} v 要检查的对象
   * @returns {boolean} 是否为Map实例
   */
  static 是否映射(v) {
    return v instanceof Map;
  }

  /**
   * 静态方法：创建映射
   * @static
   * @param {Iterable<Array<*>>} [可迭代=[]] 可迭代对象（键值对数组）
   * @returns {映射} 映射实例
   */
  static 创建(可迭代 = []) {
    return new 映射(可迭代);
  }

  /**
   * 静态方法：从普通对象创建映射
   * @static
   * @param {Object} 对象 源对象
   * @returns {映射} 映射实例
   */
  static 从对象(对象) {
    return new 映射(Object.entries(对象));
  }
}


  module.exports = {
    映射,
    default: 映射
  };
  module.exports.映射 = 映射;


// ES 模块导出
// export { 映射 };
// export default 映射;